home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / binutils.7 / binutils / binutils-2.7 / gas / write.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-04  |  71.3 KB  |  2,656 lines
  1. /* write.c - emit .o file
  2.    Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 1996
  3.    Free Software Foundation, Inc.
  4.  
  5.    This file is part of GAS, the GNU Assembler.
  6.  
  7.    GAS is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 2, or (at your option)
  10.    any later version.
  11.  
  12.    GAS is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License
  18.    along with GAS; see the file COPYING.  If not, write to
  19.    the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20.  
  21. /* This thing should be set up to do byteordering correctly.  But... */
  22.  
  23. #include "as.h"
  24. #include "subsegs.h"
  25. #include "obstack.h"
  26. #include "output-file.h"
  27.  
  28. /* This looks like a good idea.  Let's try turning it on always, for now.  */
  29. #undef  BFD_FAST_SECTION_FILL
  30. #define BFD_FAST_SECTION_FILL
  31.  
  32. /* The NOP_OPCODE is for the alignment fill value.  Fill it with a nop
  33.    instruction so that the disassembler does not choke on it.  */
  34. #ifndef NOP_OPCODE
  35. #define NOP_OPCODE 0x00
  36. #endif
  37.  
  38. #ifndef TC_ADJUST_RELOC_COUNT
  39. #define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
  40. #endif
  41.  
  42. #ifndef TC_FORCE_RELOCATION
  43. #define TC_FORCE_RELOCATION(FIXP) 0
  44. #endif
  45.  
  46. #ifndef TC_FORCE_RELOCATION_SECTION
  47. #define TC_FORCE_RELOCATION_SECTION(FIXP,SEG) TC_FORCE_RELOCATION(FIXP)
  48. #endif
  49.  
  50. #ifndef    MD_PCREL_FROM_SECTION
  51. #define MD_PCREL_FROM_SECTION(FIXP, SEC) md_pcrel_from(FIXP)
  52. #endif
  53.  
  54. #ifndef WORKING_DOT_WORD
  55. extern CONST int md_short_jump_size;
  56. extern CONST int md_long_jump_size;
  57. #endif
  58.  
  59. int symbol_table_frozen;
  60. void print_fixup PARAMS ((fixS *));
  61.  
  62. #ifdef BFD_ASSEMBLER
  63. static void renumber_sections PARAMS ((bfd *, asection *, PTR));
  64.  
  65. /* We generally attach relocs to frag chains.  However, after we have
  66.    chained these all together into a segment, any relocs we add after
  67.    that must be attached to a segment.  This will include relocs added
  68.    in md_estimate_size_for_relax, for example.  */
  69. static int frags_chained = 0;
  70. #endif
  71.  
  72. #ifndef BFD_ASSEMBLER
  73.  
  74. #ifndef MANY_SEGMENTS
  75. struct frag *text_frag_root;
  76. struct frag *data_frag_root;
  77. struct frag *bss_frag_root;
  78.  
  79. struct frag *text_last_frag;    /* Last frag in segment. */
  80. struct frag *data_last_frag;    /* Last frag in segment. */
  81. static struct frag *bss_last_frag;    /* Last frag in segment. */
  82. #endif
  83.  
  84. #ifndef BFD
  85. static object_headers headers;
  86. #endif
  87.  
  88. long string_byte_count;
  89. char *next_object_file_charP;    /* Tracks object file bytes. */
  90.  
  91. #ifndef OBJ_VMS
  92. int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
  93. #endif
  94.  
  95. #endif /* BFD_ASSEMBLER */
  96.  
  97. static int n_fixups;
  98.  
  99. #ifdef BFD_ASSEMBLER
  100. static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
  101.                        symbolS *add, symbolS *sub,
  102.                        offsetT offset, int pcrel,
  103.                        bfd_reloc_code_real_type r_type));
  104. #else
  105. static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
  106.                        symbolS *add, symbolS *sub,
  107.                        offsetT offset, int pcrel,
  108.                        int r_type));
  109. #endif
  110. #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
  111. static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
  112. #endif
  113. static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
  114.  
  115. /*
  116.  *            fix_new()
  117.  *
  118.  * Create a fixS in obstack 'notes'.
  119.  */
  120. static fixS *
  121. fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
  122.           r_type)
  123.      fragS *frag;        /* Which frag? */
  124.      int where;            /* Where in that frag? */
  125.      int size;            /* 1, 2, or 4 usually. */
  126.      symbolS *add_symbol;    /* X_add_symbol. */
  127.      symbolS *sub_symbol;    /* X_op_symbol. */
  128.      offsetT offset;        /* X_add_number. */
  129.      int pcrel;            /* TRUE if PC-relative relocation. */
  130. #ifdef BFD_ASSEMBLER
  131.      bfd_reloc_code_real_type r_type; /* Relocation type */
  132. #else
  133.      int r_type;        /* Relocation type */
  134. #endif
  135. {
  136.   fixS *fixP;
  137.  
  138.   n_fixups++;
  139.  
  140.   fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
  141.  
  142.   fixP->fx_frag = frag;
  143.   fixP->fx_where = where;
  144.   fixP->fx_size = size;
  145.   /* We've made fx_size a narrow field; check that it's wide enough.  */
  146.   if (fixP->fx_size != size)
  147.     {
  148.       as_bad ("field fx_size too small to hold %d", size);
  149.       abort ();
  150.     }
  151.   fixP->fx_addsy = add_symbol;
  152.   fixP->fx_subsy = sub_symbol;
  153.   fixP->fx_offset = offset;
  154.   fixP->fx_pcrel = pcrel;
  155.   fixP->fx_plt = 0;
  156. #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
  157.   fixP->fx_r_type = r_type;
  158. #endif
  159.   fixP->fx_im_disp = 0;
  160.   fixP->fx_pcrel_adjust = 0;
  161.   fixP->fx_bit_fixP = 0;
  162.   fixP->fx_addnumber = 0;
  163.   fixP->fx_tcbit = 0;
  164.   fixP->fx_done = 0;
  165.  
  166. #ifdef TC_FIX_TYPE
  167.   TC_INIT_FIX_DATA(fixP);
  168. #endif
  169.  
  170.   as_where (&fixP->fx_file, &fixP->fx_line);
  171.  
  172.   /* Usually, we want relocs sorted numerically, but while
  173.      comparing to older versions of gas that have relocs
  174.      reverse sorted, it is convenient to have this compile
  175.      time option.  xoxorich. */
  176.  
  177.   {
  178.  
  179. #ifdef BFD_ASSEMBLER
  180.     fixS **seg_fix_rootP = (frags_chained
  181.                 ? &seg_info (now_seg)->fix_root
  182.                 : &frchain_now->fix_root);
  183.     fixS **seg_fix_tailP = (frags_chained
  184.                 ? &seg_info (now_seg)->fix_tail
  185.                 : &frchain_now->fix_tail);
  186. #endif
  187.  
  188. #ifdef REVERSE_SORT_RELOCS
  189.  
  190.     fixP->fx_next = *seg_fix_rootP;
  191.     *seg_fix_rootP = fixP;
  192.  
  193. #else /* REVERSE_SORT_RELOCS */
  194.  
  195.     fixP->fx_next = NULL;
  196.  
  197.     if (*seg_fix_tailP)
  198.       (*seg_fix_tailP)->fx_next = fixP;
  199.     else
  200.       *seg_fix_rootP = fixP;
  201.     *seg_fix_tailP = fixP;
  202.  
  203. #endif /* REVERSE_SORT_RELOCS */
  204.  
  205.   }
  206.  
  207.   return fixP;
  208. }
  209.  
  210. /* Create a fixup relative to a symbol (plus a constant).  */
  211.  
  212. fixS *
  213. fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
  214.      fragS *frag;        /* Which frag? */
  215.      int where;            /* Where in that frag? */
  216.      int size;            /* 1, 2, or 4 usually. */
  217.      symbolS *add_symbol;    /* X_add_symbol. */
  218.      offsetT offset;        /* X_add_number. */
  219.      int pcrel;            /* TRUE if PC-relative relocation. */
  220. #ifdef BFD_ASSEMBLER
  221.      bfd_reloc_code_real_type r_type; /* Relocation type */
  222. #else
  223.      int r_type;        /* Relocation type */
  224. #endif
  225. {
  226.   return fix_new_internal (frag, where, size, add_symbol,
  227.                (symbolS *) NULL, offset, pcrel, r_type);
  228. }
  229.  
  230. /* Create a fixup for an expression.  Currently we only support fixups
  231.    for difference expressions.  That is itself more than most object
  232.    file formats support anyhow.  */
  233.  
  234. fixS *
  235. fix_new_exp (frag, where, size, exp, pcrel, r_type)
  236.      fragS *frag;        /* Which frag? */
  237.      int where;            /* Where in that frag? */
  238.      int size;            /* 1, 2, or 4 usually. */
  239.      expressionS *exp;        /* Expression.  */
  240.      int pcrel;            /* TRUE if PC-relative relocation. */
  241. #ifdef BFD_ASSEMBLER
  242.      bfd_reloc_code_real_type r_type; /* Relocation type */
  243. #else
  244.      int r_type;        /* Relocation type */
  245. #endif
  246. {
  247.   symbolS *add = NULL;
  248.   symbolS *sub = NULL;
  249.   offsetT off = 0;
  250.  
  251.   switch (exp->X_op)
  252.     {
  253.     case O_absent:
  254.       break;
  255.  
  256.     case O_add:
  257.       /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
  258.      the difference expression cannot immediately be reduced.  */
  259.       {
  260.     extern symbolS *make_expr_symbol ();
  261.     symbolS *stmp = make_expr_symbol (exp);
  262.     exp->X_op = O_symbol;
  263.     exp->X_op_symbol = 0;
  264.     exp->X_add_symbol = stmp;
  265.     exp->X_add_number = 0;
  266.     return fix_new_exp (frag, where, size, exp, pcrel, r_type);
  267.       }
  268.  
  269.     case O_symbol_rva:
  270.       add = exp->X_add_symbol;
  271.       off = exp->X_add_number;
  272.  
  273. #if defined(BFD_ASSEMBLER)
  274.       r_type = BFD_RELOC_RVA;
  275. #else
  276. #if defined(TC_RVA_RELOC)
  277.       r_type = TC_RVA_RELOC;
  278. #else
  279.       as_fatal("rva not supported");
  280. #endif
  281. #endif
  282.       break;
  283.  
  284.     case O_uminus:
  285.       sub = exp->X_add_symbol;
  286.       off = exp->X_add_number;
  287.       break;
  288.  
  289.     case O_subtract:
  290.       sub = exp->X_op_symbol;
  291.       /* Fall through.  */
  292.     case O_symbol:
  293.       add = exp->X_add_symbol;
  294.       /* Fall through.   */
  295.     case O_constant:
  296.       off = exp->X_add_number;
  297.       break;
  298.       
  299.     default:
  300.       as_bad ("expression too complex for fixup");
  301.     }
  302.  
  303.   return fix_new_internal (frag, where, size, add, sub, off,
  304.                pcrel, r_type);
  305. }
  306.  
  307. /* Append a string onto another string, bumping the pointer along.  */
  308. void
  309. append (charPP, fromP, length)
  310.      char **charPP;
  311.      char *fromP;
  312.      unsigned long length;
  313. {
  314.   /* Don't trust memcpy() of 0 chars. */
  315.   if (length == 0)
  316.     return;
  317.  
  318.   memcpy (*charPP, fromP, length);
  319.   *charPP += length;
  320. }
  321.  
  322. #ifndef BFD_ASSEMBLER 
  323. int section_alignment[SEG_MAXIMUM_ORDINAL];
  324. #endif
  325.  
  326. /*
  327.  * This routine records the largest alignment seen for each segment.
  328.  * If the beginning of the segment is aligned on the worst-case
  329.  * boundary, all of the other alignments within it will work.  At
  330.  * least one object format really uses this info.
  331.  */
  332. void 
  333. record_alignment (seg, align)
  334.      /* Segment to which alignment pertains */
  335.      segT seg;
  336.      /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
  337.     boundary, etc.)  */
  338.      int align;
  339. {
  340.   if (seg == absolute_section)
  341.     return;
  342. #ifdef BFD_ASSEMBLER
  343.   if (align > bfd_get_section_alignment (stdoutput, seg))
  344.     bfd_set_section_alignment (stdoutput, seg, align);
  345. #else
  346.   if (align > section_alignment[(int) seg])
  347.     section_alignment[(int) seg] = align;
  348. #endif
  349. }
  350.  
  351. #ifdef BFD_ASSEMBLER
  352.  
  353. /* Reset the section indices after removing the gas created sections.  */
  354.  
  355. static void
  356. renumber_sections (abfd, sec, countparg)
  357.      bfd *abfd;
  358.      asection *sec;
  359.      PTR countparg;
  360. {
  361.   int *countp = (int *) countparg;
  362.  
  363.   sec->index = *countp;
  364.   ++*countp;
  365. }
  366.  
  367. #endif /* defined (BFD_ASSEMBLER) */
  368.  
  369. #if defined (BFD_ASSEMBLER) || ! defined (BFD)
  370.  
  371. static fragS *
  372. chain_frchains_together_1 (section, frchp)
  373.      segT section;
  374.      struct frchain *frchp;
  375. {
  376.   fragS dummy, *prev_frag = &dummy;
  377. #ifdef BFD_ASSEMBLER
  378.   fixS fix_dummy, *prev_fix = &fix_dummy;
  379. #endif
  380.  
  381.   for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
  382.     {
  383.       prev_frag->fr_next = frchp->frch_root;
  384.       prev_frag = frchp->frch_last;
  385.       assert (prev_frag->fr_type != 0);
  386. #ifdef BFD_ASSEMBLER
  387.       if (frchp->fix_root != (fixS *) NULL)
  388.     {
  389.       if (seg_info (section)->fix_root == (fixS *) NULL)
  390.         seg_info (section)->fix_root = frchp->fix_root;
  391.       prev_fix->fx_next = frchp->fix_root;
  392.       seg_info (section)->fix_tail = frchp->fix_tail;
  393.       prev_fix = frchp->fix_tail;
  394.     }
  395. #endif
  396.     }
  397.   assert (prev_frag->fr_type != 0);
  398.   prev_frag->fr_next = 0;
  399.   return prev_frag;
  400. }
  401.  
  402. #endif
  403.  
  404. #ifdef BFD_ASSEMBLER
  405.  
  406. static void
  407. chain_frchains_together (abfd, section, xxx)
  408.      bfd *abfd;            /* unused */
  409.      segT section;
  410.      PTR xxx;            /* unused */
  411. {
  412.   segment_info_type *info;
  413.  
  414.   /* BFD may have introduced its own sections without using
  415.      subseg_new, so it is possible that seg_info is NULL.  */
  416.   info = seg_info (section);
  417.   if (info != (segment_info_type *) NULL)
  418.    info->frchainP->frch_last
  419.      = chain_frchains_together_1 (section, info->frchainP);
  420.  
  421.   /* Now that we've chained the frags together, we must add new fixups
  422.      to the segment, not to the frag chain.  */
  423.   frags_chained = 1;
  424. }
  425.  
  426. #endif
  427.  
  428. #if !defined (BFD) && !defined (BFD_ASSEMBLER)
  429.  
  430. void 
  431. remove_subsegs (head, seg, root, last)
  432.      frchainS *head;
  433.      int seg;
  434.      fragS **root;
  435.      fragS **last;
  436. {
  437.   *root = head->frch_root;
  438.   *last = chain_frchains_together_1 (seg, head);
  439. }
  440.  
  441. #endif /* BFD */
  442.  
  443. #if defined (BFD_ASSEMBLER) || !defined (BFD)
  444.  
  445. #ifdef BFD_ASSEMBLER
  446. static void
  447. cvt_frag_to_fill (sec, fragP)
  448.      segT sec;
  449.      fragS *fragP;
  450. #else
  451. static void
  452. cvt_frag_to_fill (headersP, sec, fragP)
  453.      object_headers *headersP;
  454.      segT sec;
  455.      fragS *fragP;
  456. #endif
  457. {
  458.   switch (fragP->fr_type)
  459.     {
  460.     case rs_align:
  461.     case rs_align_code:
  462.     case rs_org:
  463.     case rs_space:
  464. #ifdef HANDLE_ALIGN
  465.       HANDLE_ALIGN (fragP);
  466. #endif
  467.       know (fragP->fr_next != NULL);
  468.       fragP->fr_offset = (fragP->fr_next->fr_address
  469.               - fragP->fr_address
  470.               - fragP->fr_fix) / fragP->fr_var;
  471.       if (fragP->fr_offset < 0)
  472.     {
  473.       as_bad ("attempt to .org/.space backwards? (%ld)",
  474.           (long) fragP->fr_offset);
  475.     }
  476.       fragP->fr_type = rs_fill;
  477.       break;
  478.  
  479.     case rs_fill:
  480.       break;
  481.  
  482.     case rs_machine_dependent:
  483. #ifdef BFD_ASSEMBLER
  484.       md_convert_frag (stdoutput, sec, fragP);
  485. #else
  486.       md_convert_frag (headersP, sec, fragP);
  487. #endif
  488.  
  489.       assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
  490.  
  491.       /*
  492.        * After md_convert_frag, we make the frag into a ".space 0".
  493.        * Md_convert_frag() should set up any fixSs and constants
  494.        * required.
  495.        */
  496.       frag_wane (fragP);
  497.       break;
  498.  
  499. #ifndef WORKING_DOT_WORD
  500.     case rs_broken_word:
  501.       {
  502.     struct broken_word *lie;
  503.  
  504.     if (fragP->fr_subtype)
  505.       {
  506.         fragP->fr_fix += md_short_jump_size;
  507.         for (lie = (struct broken_word *) (fragP->fr_symbol);
  508.          lie && lie->dispfrag == fragP;
  509.          lie = lie->next_broken_word)
  510.           if (lie->added == 1)
  511.         fragP->fr_fix += md_long_jump_size;
  512.       }
  513.     frag_wane (fragP);
  514.       }
  515.       break;
  516. #endif
  517.  
  518.     default:
  519.       BAD_CASE (fragP->fr_type);
  520.       break;
  521.     }
  522. }
  523.  
  524. #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
  525.  
  526. #ifdef BFD_ASSEMBLER
  527. static void
  528. relax_and_size_seg (abfd, sec, xxx)
  529.      bfd *abfd;
  530.      asection *sec;
  531.      PTR xxx;
  532. {
  533.   flagword flags;
  534.   fragS *fragp;
  535.   segment_info_type *seginfo;
  536.   int x;
  537.   valueT size, newsize;
  538.  
  539.   subseg_change (sec, 0);
  540.  
  541.   flags = bfd_get_section_flags (abfd, sec);
  542.  
  543.   seginfo = seg_info (sec);
  544.   if (seginfo && seginfo->frchainP)
  545.     {
  546.       relax_segment (seginfo->frchainP->frch_root, sec);
  547.       for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
  548.     cvt_frag_to_fill (sec, fragp);
  549.       for (fragp = seginfo->frchainP->frch_root;
  550.        fragp->fr_next;
  551.        fragp = fragp->fr_next)
  552.     /* walk to last elt */;
  553.       size = fragp->fr_address + fragp->fr_fix;
  554.     }
  555.   else
  556.     size = 0;
  557.  
  558.   if (size > 0 && ! seginfo->bss)
  559.     flags |= SEC_HAS_CONTENTS;
  560.  
  561.   /* @@ This is just an approximation.  */
  562.   if (seginfo && seginfo->fix_root)
  563.     flags |= SEC_RELOC;
  564.   else
  565.     flags &= ~SEC_RELOC;
  566.   x = bfd_set_section_flags (abfd, sec, flags);
  567.   assert (x == true);
  568.  
  569.   newsize = md_section_align (sec, size);
  570.   x = bfd_set_section_size (abfd, sec, newsize);
  571.   assert (x == true);
  572.  
  573.   /* If the size had to be rounded up, add some padding in the last
  574.      non-empty frag.  */
  575.   assert (newsize >= size);
  576.   if (size != newsize)
  577.     {
  578.       fragS *last = seginfo->frchainP->frch_last;
  579.       fragp = seginfo->frchainP->frch_root;
  580.       while (fragp->fr_next != last)
  581.     fragp = fragp->fr_next;
  582.       last->fr_address = size;
  583.       fragp->fr_offset += newsize - size;
  584.     }
  585.  
  586. #ifdef tc_frob_section
  587.   tc_frob_section (sec);
  588. #endif
  589. #ifdef obj_frob_section
  590.   obj_frob_section (sec);
  591. #endif
  592. }
  593.  
  594. #ifdef DEBUG2
  595. static void
  596. dump_section_relocs (abfd, sec, stream_)
  597.      bfd *abfd;
  598.      asection *sec;
  599.      char *stream_;
  600. {
  601.   FILE *stream = (FILE *) stream_;
  602.   segment_info_type *seginfo = seg_info (sec);
  603.   fixS *fixp = seginfo->fix_root;
  604.  
  605.   if (!fixp)
  606.     return;
  607.  
  608.   fprintf (stream, "sec %s relocs:\n", sec->name);
  609.   while (fixp)
  610.     {
  611.       symbolS *s = fixp->fx_addsy;
  612.       if (s)
  613.     {
  614.       fprintf (stream, "  %08x: %s(%s", fixp, S_GET_NAME (s),
  615.            s->bsym->section->name);
  616.       if (s->bsym->flags & BSF_SECTION_SYM)
  617.         {
  618.           fprintf (stream, " section sym");
  619.           if (S_GET_VALUE (s))
  620.         fprintf (stream, "+%x", S_GET_VALUE (s));
  621.         }
  622.       else
  623.         fprintf (stream, "+%x", S_GET_VALUE (s));
  624.       fprintf (stream, ")+%x\n", fixp->fx_offset);
  625.     }
  626.       else
  627.     fprintf (stream, "  %08x: type %d no sym\n", fixp, fixp->fx_r_type);
  628.       fixp = fixp->fx_next;
  629.     }
  630. }
  631. #else
  632. #define dump_section_relocs(ABFD,SEC,STREAM)    ((void) 0)
  633. #endif
  634.  
  635. #ifndef EMIT_SECTION_SYMBOLS
  636. #define EMIT_SECTION_SYMBOLS 1
  637. #endif
  638.  
  639. static void
  640. adjust_reloc_syms (abfd, sec, xxx)
  641.      bfd *abfd;
  642.      asection *sec;
  643.      PTR xxx;
  644. {
  645.   segment_info_type *seginfo = seg_info (sec);
  646.   fixS *fixp;
  647.  
  648.   if (seginfo == NULL)
  649.     return;
  650.  
  651.   dump_section_relocs (abfd, sec, stderr);
  652.  
  653.   for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
  654.     if (fixp->fx_done)
  655.       /* ignore it */;
  656.     else if (fixp->fx_addsy)
  657.       {
  658.     symbolS *sym;
  659.     asection *symsec;
  660.  
  661.       reduce_fixup:
  662.  
  663. #ifdef DEBUG5
  664.     fprintf (stderr, "\n\nadjusting fixup:\n");
  665.     print_fixup (fixp);
  666. #endif
  667.  
  668.     sym = fixp->fx_addsy;
  669.     symsec = sym->bsym->section;
  670.  
  671.     if (sym != NULL && sym->sy_mri_common)
  672.       {
  673.         /* These symbols are handled specially in fixup_segment.  */
  674.         goto done;
  675.       }
  676.  
  677.     if (bfd_is_abs_section (symsec))
  678.       {
  679.         /* The fixup_segment routine will not use this symbol in a
  680.                relocation unless TC_FORCE_RELOCATION returns 1.  */
  681.         if (TC_FORCE_RELOCATION (fixp))
  682.           {
  683.         fixp->fx_addsy->sy_used_in_reloc = 1;
  684. #ifdef UNDEFINED_DIFFERENCE_OK
  685.         if (fixp->fx_subsy != NULL)
  686.           fixp->fx_subsy->sy_used_in_reloc = 1;
  687. #endif
  688.           }
  689.         goto done;
  690.       }
  691.  
  692.     /* If it's one of these sections, assume the symbol is
  693.        definitely going to be output.  The code in
  694.        md_estimate_size_before_relax in tc-mips.c uses this test
  695.        as well, so if you change this code you should look at that
  696.        code.  */
  697.     if (bfd_is_und_section (symsec)
  698.         || bfd_is_com_section (symsec))
  699.       {
  700.         fixp->fx_addsy->sy_used_in_reloc = 1;
  701. #ifdef UNDEFINED_DIFFERENCE_OK
  702.         /* We have the difference of an undefined symbol and some
  703.            other symbol.  Make sure to mark the other symbol as used
  704.            in a relocation so that it will always be output.  */
  705.         if (fixp->fx_subsy)
  706.           fixp->fx_subsy->sy_used_in_reloc = 1;
  707. #endif
  708.         goto done;
  709.       }
  710.  
  711.     /* Since we're reducing to section symbols, don't attempt to reduce
  712.        anything that's already using one.  */
  713.     if (sym->bsym->flags & BSF_SECTION_SYM)
  714.       {
  715.         fixp->fx_addsy->sy_used_in_reloc = 1;
  716.         goto done;
  717.       }
  718.  
  719.     /* Is there some other reason we can't adjust this one?  (E.g.,
  720.        call/bal links in i960-bout symbols.)  */
  721. #ifdef obj_fix_adjustable
  722.     if (! obj_fix_adjustable (fixp))
  723.       {
  724.         fixp->fx_addsy->sy_used_in_reloc = 1;
  725.         goto done;
  726.       }
  727. #endif
  728.  
  729.     /* Is there some other (target cpu dependent) reason we can't adjust
  730.        this one?  (E.g. relocations involving function addresses on 
  731.        the PA.  */
  732. #ifdef tc_fix_adjustable
  733.     if (! tc_fix_adjustable (fixp))
  734.       {
  735.         fixp->fx_addsy->sy_used_in_reloc = 1;
  736.         goto done;
  737.       }
  738. #endif
  739.  
  740.     /* For PIC support: We may get expressions like
  741.        "_GLOBAL_OFFSET_TABLE_+(.-L5)" where "." and "L5" may not
  742.        necessarily have had a fixed difference initially.  But now
  743.        it should be a known constant, so we can reduce it.  Since
  744.        we can't easily handle a symbol value that looks like
  745.        someUndefinedSymbol+const, though, we convert the fixup to
  746.        access the undefined symbol directly, and discard the
  747.        intermediate symbol.  */
  748.     if (S_GET_SEGMENT (sym) == expr_section
  749.         && sym->sy_value.X_op == O_add
  750.         && (resolve_symbol_value (sym->sy_value.X_add_symbol),
  751.         S_GET_SEGMENT (sym->sy_value.X_add_symbol) == undefined_section)
  752.         && (resolve_symbol_value (sym->sy_value.X_op_symbol),
  753.         S_GET_SEGMENT (sym->sy_value.X_op_symbol) == absolute_section))
  754.       {
  755.         fixp->fx_offset += S_GET_VALUE (sym->sy_value.X_op_symbol);
  756.         fixp->fx_offset += sym->sy_value.X_add_number;
  757.         fixp->fx_addsy = sym->sy_value.X_add_symbol;
  758.         goto reduce_fixup;
  759.       }
  760.  
  761.     /* If the section symbol isn't going to be output, the relocs
  762.        at least should still work.  If not, figure out what to do
  763.        when we run into that case.
  764.  
  765.        We refetch the segment when calling section_symbol, rather
  766.        than using symsec, because S_GET_VALUE may wind up changing
  767.        the section when it calls resolve_symbol_value. */
  768.     fixp->fx_offset += S_GET_VALUE (sym);
  769.     fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
  770.     fixp->fx_addsy->sy_used_in_reloc = 1;
  771.  
  772.       done:
  773.     ;
  774.       }
  775. #if 1/*def RELOC_REQUIRES_SYMBOL*/
  776.     else
  777.       {
  778.     /* There was no symbol required by this relocation.  However,
  779.        BFD doesn't really handle relocations without symbols well.
  780.        (At least, the COFF support doesn't.)  So for now we fake up
  781.        a local symbol in the absolute section.  */
  782.  
  783.     fixp->fx_addsy = section_symbol (absolute_section);
  784. /*    fixp->fx_addsy->sy_used_in_reloc = 1; */
  785.       }
  786. #endif
  787.  
  788.   dump_section_relocs (abfd, sec, stderr);
  789. }
  790.  
  791. static void
  792. write_relocs (abfd, sec, xxx)
  793.      bfd *abfd;
  794.      asection *sec;
  795.      PTR xxx;
  796. {
  797.   segment_info_type *seginfo = seg_info (sec);
  798.   int i;
  799.   unsigned int n;
  800.   arelent **relocs;
  801.   fixS *fixp;
  802.   char *err;
  803.  
  804.   /* If seginfo is NULL, we did not create this section; don't do
  805.      anything with it.  */
  806.   if (seginfo == NULL)
  807.     return;
  808.  
  809.   fixup_segment (seginfo->fix_root, sec);
  810.  
  811.   n = 0;
  812.   for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
  813.     n++;
  814.  
  815. #ifndef RELOC_EXPANSION_POSSIBLE
  816.   /* Set up reloc information as well.  */
  817.   relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
  818.                          n * sizeof (arelent *));
  819.   memset ((char*)relocs, 0, n * sizeof (arelent*));
  820.  
  821.   i = 0;
  822.   for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
  823.     {
  824.       arelent *reloc;
  825.       bfd_reloc_status_type s;
  826.       symbolS *sym;
  827.  
  828.       if (fixp->fx_done)
  829.     {
  830.       n--;
  831.       continue;
  832.     }
  833.  
  834.       /* If this is an undefined symbol which was equated to another
  835.          symbol, then use generate the reloc against the latter symbol
  836.          rather than the former.  */
  837.       sym = fixp->fx_addsy;
  838.       while (sym->sy_value.X_op == O_symbol
  839.          && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
  840.     sym = sym->sy_value.X_add_symbol;
  841.       fixp->fx_addsy = sym;
  842.  
  843.       reloc = tc_gen_reloc (sec, fixp);
  844.       if (!reloc)
  845.     {
  846.       n--;
  847.       continue;
  848.     }
  849.       if (fixp->fx_where + fixp->fx_size
  850.       > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
  851.     abort ();
  852.  
  853.       s = bfd_install_relocation (stdoutput, reloc,
  854.                   fixp->fx_frag->fr_literal,
  855.                   fixp->fx_frag->fr_address,
  856.                   sec, &err);
  857.       switch (s)
  858.     {
  859.     case bfd_reloc_ok:
  860.       break;
  861.     case bfd_reloc_overflow:
  862.       as_bad_where (fixp->fx_file, fixp->fx_line, "relocation overflow");
  863.       break;
  864.     default:
  865.       as_fatal ("%s:%u: bad return from bfd_perform_relocation",
  866.             fixp->fx_file, fixp->fx_line);
  867.     }
  868.       relocs[i++] = reloc;
  869.     }
  870. #else
  871.   n = n * MAX_RELOC_EXPANSION;
  872.   /* Set up reloc information as well.  */
  873.   relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
  874.                          n * sizeof (arelent *));
  875.  
  876.   i = 0;
  877.   for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
  878.     {
  879.       arelent **reloc;
  880.       char *data;
  881.       bfd_reloc_status_type s;
  882.       symbolS *sym;
  883.       int j;
  884.  
  885.       if (fixp->fx_done)
  886.     {
  887.       n--;
  888.       continue;
  889.     }
  890.  
  891.       /* If this is an undefined symbol which was equated to another
  892.          symbol, then use generate the reloc against the latter symbol
  893.          rather than the former.  */
  894.       sym = fixp->fx_addsy;
  895.       while (sym->sy_value.X_op == O_symbol
  896.          && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
  897.     sym = sym->sy_value.X_add_symbol;
  898.       fixp->fx_addsy = sym;
  899.  
  900.       reloc = tc_gen_reloc (sec, fixp);
  901.  
  902.       for (j = 0; reloc[j]; j++)
  903.     {
  904.           relocs[i++] = reloc[j];
  905.           assert(i <= n);
  906.     }
  907.       data = fixp->fx_frag->fr_literal + fixp->fx_where;
  908.       if (fixp->fx_where + fixp->fx_size
  909.       > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
  910.     abort ();
  911.       for (j = 0; reloc[j]; j++)
  912.         {
  913.       s = bfd_install_relocation (stdoutput, reloc[j],
  914.                       fixp->fx_frag->fr_literal,
  915.                       fixp->fx_frag->fr_address,
  916.                       sec, &err);
  917.           switch (s)
  918.         {
  919.         case bfd_reloc_ok:
  920.           break;
  921.         case bfd_reloc_overflow:
  922.           as_bad_where (fixp->fx_file, fixp->fx_line,
  923.                 "relocation overflow");
  924.           break;
  925.         default:
  926.           as_fatal ("%s:%u: bad return from bfd_perform_relocation",
  927.             fixp->fx_file, fixp->fx_line);
  928.         }
  929.         }
  930.     }
  931.   n = i;
  932. #endif
  933.  
  934. #ifdef DEBUG4
  935.   {
  936.     int i, j, nsyms;
  937.     asymbol **sympp;
  938.     sympp = bfd_get_outsymbols (stdoutput);
  939.     nsyms = bfd_get_symcount (stdoutput);
  940.     for (i = 0; i < n; i++)
  941.       if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
  942.     {
  943.       for (j = 0; j < nsyms; j++)
  944.         if (sympp[j] == *relocs[i]->sym_ptr_ptr)
  945.           break;
  946.       if (j == nsyms)
  947.         abort ();
  948.     }
  949.   }
  950. #endif
  951.  
  952.   if (n)
  953.     bfd_set_reloc (stdoutput, sec, relocs, n);
  954.   else
  955.     bfd_set_section_flags (abfd, sec,
  956.                (bfd_get_section_flags (abfd, sec)
  957.                 & (flagword) ~SEC_RELOC));
  958.  
  959. #ifdef DEBUG3
  960.   {
  961.     int i;
  962.     arelent *r;
  963.     asymbol *s;
  964.     fprintf (stderr, "relocs for sec %s\n", sec->name);
  965.     for (i = 0; i < n; i++)
  966.       {
  967.     r = relocs[i];
  968.     s = *r->sym_ptr_ptr;
  969.     fprintf (stderr, "  reloc %2d @%08x off %4x : sym %-10s addend %x\n",
  970.          i, r, r->address, s->name, r->addend);
  971.       }
  972.   }
  973. #endif
  974. }
  975.  
  976. static void
  977. write_contents (abfd, sec, xxx)
  978.      bfd *abfd;
  979.      asection *sec;
  980.      PTR xxx;
  981. {
  982.   segment_info_type *seginfo = seg_info (sec);
  983.   unsigned long offset = 0;
  984.   fragS *f;
  985.  
  986.   /* Write out the frags.  */
  987.   if (seginfo == NULL
  988.       || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
  989.     return;
  990.  
  991.   for (f = seginfo->frchainP->frch_root;
  992.        f;
  993.        f = f->fr_next)
  994.     {
  995.       int x;
  996.       unsigned long fill_size;
  997.       char *fill_literal;
  998.       long count;
  999.  
  1000.       assert (f->fr_type == rs_fill);
  1001.       if (f->fr_fix)
  1002.     {
  1003.       x = bfd_set_section_contents (stdoutput, sec,
  1004.                     f->fr_literal, (file_ptr) offset,
  1005.                     (bfd_size_type) f->fr_fix);
  1006.       if (x == false)
  1007.         {
  1008.           bfd_perror (stdoutput->filename);
  1009.           as_perror ("FATAL: Can't write %s", stdoutput->filename);
  1010.           exit (EXIT_FAILURE);
  1011.         }
  1012.       offset += f->fr_fix;
  1013.     }
  1014.       fill_literal = f->fr_literal + f->fr_fix;
  1015.       fill_size = f->fr_var;
  1016.       count = f->fr_offset;
  1017.       assert (count >= 0);
  1018.       if (fill_size && count)
  1019.     {
  1020.       char buf[256];
  1021.       if (fill_size > sizeof(buf))
  1022.         {
  1023.           /* Do it the old way. Can this ever happen? */
  1024.           while (count--)
  1025.         {
  1026.           x = bfd_set_section_contents (stdoutput, sec,
  1027.                         fill_literal,
  1028.                         (file_ptr) offset,
  1029.                         (bfd_size_type) fill_size);
  1030.           if (x == false)
  1031.             {
  1032.               bfd_perror (stdoutput->filename);
  1033.               as_perror ("FATAL: Can't write %s", stdoutput->filename);
  1034.               exit (EXIT_FAILURE);
  1035.             }
  1036.           offset += fill_size;
  1037.         }
  1038.         }
  1039.       else
  1040.         {
  1041.           /* Build a buffer full of fill objects and output it as
  1042.          often as necessary. This saves on the overhead of
  1043.          potentially lots of bfd_set_section_contents calls.  */
  1044.           int n_per_buf, i;
  1045.           if (fill_size == 1)
  1046.         {
  1047.           n_per_buf = sizeof (buf);
  1048.           memset (buf, *fill_literal, n_per_buf);
  1049.         }
  1050.           else
  1051.         {
  1052.           char *bufp;
  1053.           n_per_buf = sizeof(buf)/fill_size;
  1054.           for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
  1055.             memcpy(bufp, fill_literal, fill_size);
  1056.         }
  1057.           for (; count > 0; count -= n_per_buf)
  1058.         {
  1059.           n_per_buf = n_per_buf > count ? count : n_per_buf;
  1060.           x = bfd_set_section_contents (stdoutput, sec,
  1061.                         buf, (file_ptr) offset,
  1062.                         (bfd_size_type) n_per_buf * fill_size);
  1063.           if (x != true)
  1064.             as_fatal ("Cannot write to output file.");
  1065.           offset += n_per_buf * fill_size;
  1066.         }
  1067.         }
  1068.     }
  1069.     }
  1070. }
  1071. #endif
  1072.  
  1073. #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
  1074. static void
  1075. merge_data_into_text ()
  1076. {
  1077. #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
  1078.   seg_info (text_section)->frchainP->frch_last->fr_next =
  1079.     seg_info (data_section)->frchainP->frch_root;
  1080.   seg_info (text_section)->frchainP->frch_last =
  1081.     seg_info (data_section)->frchainP->frch_last;
  1082.   seg_info (data_section)->frchainP = 0;
  1083. #else
  1084.   fixS *tmp;
  1085.  
  1086.   text_last_frag->fr_next = data_frag_root;
  1087.   text_last_frag = data_last_frag;
  1088.   data_last_frag = NULL;
  1089.   data_frag_root = NULL;
  1090.   if (text_fix_root)
  1091.     {
  1092.       for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
  1093.       tmp->fx_next = data_fix_root;
  1094.       text_fix_tail = data_fix_tail;
  1095.     }
  1096.   else
  1097.     text_fix_root = data_fix_root;
  1098.   data_fix_root = NULL;
  1099. #endif
  1100. }
  1101. #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
  1102.  
  1103. #if !defined (BFD_ASSEMBLER) && !defined (BFD)
  1104. static void
  1105. relax_and_size_all_segments ()
  1106. {
  1107.   fragS *fragP;
  1108.  
  1109.   relax_segment (text_frag_root, SEG_TEXT);
  1110.   relax_segment (data_frag_root, SEG_DATA);
  1111.   relax_segment (bss_frag_root, SEG_BSS);
  1112.   /*
  1113.    * Now the addresses of frags are correct within the segment.
  1114.    */
  1115.  
  1116.   know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
  1117.   H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
  1118.   text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
  1119.  
  1120.   /*
  1121.    * Join the 2 segments into 1 huge segment.
  1122.    * To do this, re-compute every rn_address in the SEG_DATA frags.
  1123.    * Then join the data frags after the text frags.
  1124.    *
  1125.    * Determine a_data [length of data segment].
  1126.    */
  1127.   if (data_frag_root)
  1128.     {
  1129.       register relax_addressT slide;
  1130.  
  1131.       know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
  1132.  
  1133.       H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
  1134.       data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
  1135.       slide = H_GET_TEXT_SIZE (&headers);    /* & in file of the data segment. */
  1136. #ifdef OBJ_BOUT
  1137. #define RoundUp(N,S) (((N)+(S)-1)&-(S))
  1138.       /* For b.out: If the data section has a strict alignment
  1139.      requirement, its load address in the .o file will be
  1140.      rounded up from the size of the text section.  These
  1141.      two values are *not* the same!  Similarly for the bss
  1142.      section....  */
  1143.       slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
  1144. #endif
  1145.  
  1146.       for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
  1147.     {
  1148.       fragP->fr_address += slide;
  1149.     }            /* for each data frag */
  1150.  
  1151.       know (text_last_frag != 0);
  1152.       text_last_frag->fr_next = data_frag_root;
  1153.     }
  1154.   else
  1155.     {
  1156.       H_SET_DATA_SIZE (&headers, 0);
  1157.     }
  1158.  
  1159. #ifdef OBJ_BOUT
  1160.   /* See above comments on b.out data section address.  */
  1161.   {
  1162.     long bss_vma;
  1163.     if (data_last_frag == 0)
  1164.       bss_vma = H_GET_TEXT_SIZE (&headers);
  1165.     else
  1166.       bss_vma = data_last_frag->fr_address;
  1167.     bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
  1168.     bss_address_frag.fr_address = bss_vma;
  1169.   }
  1170. #else /* ! OBJ_BOUT */
  1171.   bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
  1172.                  H_GET_DATA_SIZE (&headers));
  1173.  
  1174. #endif /* ! OBJ_BOUT */
  1175.  
  1176.   /* Slide all the frags */
  1177.   if (bss_frag_root)
  1178.     {
  1179.       relax_addressT slide = bss_address_frag.fr_address;
  1180.  
  1181.       for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
  1182.     {
  1183.       fragP->fr_address += slide;
  1184.     }            /* for each bss frag */
  1185.     }
  1186.  
  1187.   if (bss_last_frag)
  1188.     H_SET_BSS_SIZE (&headers,
  1189.             bss_last_frag->fr_address - bss_frag_root->fr_address);
  1190.   else
  1191.     H_SET_BSS_SIZE (&headers, 0);
  1192. }
  1193. #endif /* ! BFD_ASSEMBLER && ! BFD */
  1194.  
  1195. #if defined (BFD_ASSEMBLER) || !defined (BFD)
  1196.  
  1197. #ifdef BFD_ASSEMBLER
  1198. static void
  1199. set_symtab ()
  1200. {
  1201.   int nsyms;
  1202.   asymbol **asympp;
  1203.   symbolS *symp;
  1204.   boolean result;
  1205.   extern PTR bfd_alloc PARAMS ((bfd *, size_t));
  1206.  
  1207.   /* Count symbols.  We can't rely on a count made by the loop in
  1208.      write_object_file, because *_frob_file may add a new symbol or
  1209.      two.  */
  1210.   nsyms = 0;
  1211.   for (symp = symbol_rootP; symp; symp = symbol_next (symp))
  1212.     nsyms++;
  1213.  
  1214.   if (nsyms)
  1215.     {
  1216.       int i;
  1217.  
  1218.       asympp = (asymbol **) bfd_alloc (stdoutput,
  1219.                        nsyms * sizeof (asymbol *));
  1220.       symp = symbol_rootP;
  1221.       for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
  1222.     {
  1223.       asympp[i] = symp->bsym;
  1224.       symp->written = 1;
  1225.     }
  1226.     }
  1227.   else
  1228.     asympp = 0;
  1229.   result = bfd_set_symtab (stdoutput, asympp, nsyms);
  1230.   assert (result == true);
  1231.   symbol_table_frozen = 1;
  1232. }
  1233. #endif
  1234.  
  1235. void 
  1236. write_object_file ()
  1237. {
  1238.   struct frchain *frchainP;    /* Track along all frchains. */
  1239. #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
  1240.   fragS *fragP;            /* Track along all frags. */
  1241. #endif
  1242.  
  1243.   /* Do we really want to write it?  */
  1244.   {
  1245.     int n_warns, n_errs;
  1246.     n_warns = had_warnings ();
  1247.     n_errs = had_errors ();
  1248.     /* The -Z flag indicates that an object file should be generated,
  1249.        regardless of warnings and errors.  */
  1250.     if (flag_always_generate_output)
  1251.       {
  1252.     if (n_warns || n_errs)
  1253.       as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
  1254.            n_errs, n_errs == 1 ? "" : "s",
  1255.            n_warns, n_warns == 1 ? "" : "s");
  1256.       }
  1257.     else
  1258.       {
  1259.     if (n_errs)
  1260.       as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
  1261.             n_errs, n_errs == 1 ? "" : "s",
  1262.             n_warns, n_warns == 1 ? "" : "s");
  1263.       }
  1264.   }
  1265.  
  1266. #ifdef    OBJ_VMS
  1267.   /* Under VMS we try to be compatible with VAX-11 "C".  Thus, we call
  1268.      a routine to check for the definition of the procedure "_main",
  1269.      and if so -- fix it up so that it can be program entry point. */
  1270.   vms_check_for_main ();
  1271. #endif /* OBJ_VMS */
  1272.  
  1273.   /* After every sub-segment, we fake an ".align ...". This conforms to
  1274.      BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
  1275.      frag that requires least thought. ".align" frags like to have a
  1276.      following frag since that makes calculating their intended length
  1277.      trivial.
  1278.  
  1279.      @@ Is this really necessary??  */
  1280. #ifndef SUB_SEGMENT_ALIGN
  1281. #ifdef BFD_ASSEMBLER
  1282. #define SUB_SEGMENT_ALIGN(SEG) (0)
  1283. #else
  1284. #define SUB_SEGMENT_ALIGN(SEG) (2)
  1285. #endif
  1286. #endif
  1287.   for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
  1288.     {
  1289.       subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
  1290.       frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
  1291.       /* frag_align will have left a new frag.
  1292.      Use this last frag for an empty ".fill".
  1293.  
  1294.      For this segment ...
  1295.      Create a last frag. Do not leave a "being filled in frag".  */
  1296.       frag_wane (frag_now);
  1297.       frag_now->fr_fix = 0;
  1298.       know (frag_now->fr_next == NULL);
  1299.     }
  1300.  
  1301.   /* From now on, we don't care about sub-segments.  Build one frag chain
  1302.      for each segment. Linked thru fr_next.  */
  1303.  
  1304. #ifdef BFD_ASSEMBLER
  1305.   /* Remove the sections created by gas for its own purposes.  */
  1306.   {
  1307.     asection **seclist, *sec;
  1308.     int i;
  1309.  
  1310.     seclist = &stdoutput->sections;
  1311.     while (seclist && *seclist)
  1312.       {
  1313.     sec = *seclist;
  1314.     while (sec == reg_section || sec == expr_section)
  1315.       {
  1316.         sec = sec->next;
  1317.         *seclist = sec;
  1318.         stdoutput->section_count--;
  1319.         if (!sec)
  1320.           break;
  1321.       }
  1322.     if (*seclist)
  1323.       seclist = &(*seclist)->next;
  1324.       }
  1325.     i = 0;
  1326.     bfd_map_over_sections (stdoutput, renumber_sections, &i);
  1327.   }
  1328.  
  1329.   bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
  1330. #else
  1331.   remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
  1332.   remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
  1333.   remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
  1334. #endif
  1335.  
  1336.   /* We have two segments. If user gave -R flag, then we must put the
  1337.      data frags into the text segment. Do this before relaxing so
  1338.      we know to take advantage of -R and make shorter addresses.  */
  1339. #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
  1340.   if (flag_readonly_data_in_text)
  1341.     {
  1342.       merge_data_into_text ();
  1343.     }
  1344. #endif
  1345.  
  1346. #ifdef BFD_ASSEMBLER
  1347.   bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
  1348. #else
  1349.   relax_and_size_all_segments ();
  1350. #endif /* BFD_ASSEMBLER */
  1351.  
  1352. #ifndef BFD_ASSEMBLER
  1353.   /*
  1354.    *
  1355.    * Crawl the symbol chain.
  1356.    *
  1357.    * For each symbol whose value depends on a frag, take the address of
  1358.    * that frag and subsume it into the value of the symbol.
  1359.    * After this, there is just one way to lookup a symbol value.
  1360.    * Values are left in their final state for object file emission.
  1361.    * We adjust the values of 'L' local symbols, even if we do
  1362.    * not intend to emit them to the object file, because their values
  1363.    * are needed for fix-ups.
  1364.    *
  1365.    * Unless we saw a -L flag, remove all symbols that begin with 'L'
  1366.    * from the symbol chain.  (They are still pointed to by the fixes.)
  1367.    *
  1368.    * Count the remaining symbols.
  1369.    * Assign a symbol number to each symbol.
  1370.    * Count the number of string-table chars we will emit.
  1371.    * Put this info into the headers as appropriate.
  1372.    *
  1373.    */
  1374.   know (zero_address_frag.fr_address == 0);
  1375.   string_byte_count = sizeof (string_byte_count);
  1376.  
  1377.   obj_crawl_symbol_chain (&headers);
  1378.  
  1379.   if (string_byte_count == sizeof (string_byte_count))
  1380.     string_byte_count = 0;
  1381.  
  1382.   H_SET_STRING_SIZE (&headers, string_byte_count);
  1383.  
  1384.   /*
  1385.    * Addresses of frags now reflect addresses we use in the object file.
  1386.    * Symbol values are correct.
  1387.    * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
  1388.    * Also converting any machine-dependent frags using md_convert_frag();
  1389.    */
  1390.   subseg_change (SEG_TEXT, 0);
  1391.  
  1392.   for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
  1393.     {
  1394.       cvt_frag_to_fill (&headers, SEG_TEXT, fragP);
  1395.  
  1396.       /* Some assert macros don't work with # directives mixed in.  */
  1397. #ifndef NDEBUG
  1398.       if (!(fragP->fr_next == NULL
  1399. #ifdef OBJ_BOUT
  1400.         || fragP->fr_next == data_frag_root
  1401. #endif
  1402.         || ((fragP->fr_next->fr_address - fragP->fr_address)
  1403.         == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
  1404.     abort ();
  1405. #endif
  1406.     }
  1407. #endif /* ! BFD_ASSEMBLER */
  1408.  
  1409. #ifndef WORKING_DOT_WORD
  1410.   {
  1411.     struct broken_word *lie;
  1412.     struct broken_word **prevP;
  1413.  
  1414.     prevP = &broken_words;
  1415.     for (lie = broken_words; lie; lie = lie->next_broken_word)
  1416.       if (!lie->added)
  1417.     {
  1418.       expressionS exp;
  1419.  
  1420.       exp.X_op = O_subtract;
  1421.       exp.X_add_symbol = lie->add;
  1422.       exp.X_op_symbol = lie->sub;
  1423.       exp.X_add_number = lie->addnum;
  1424. #ifdef BFD_ASSEMBLER
  1425. #ifdef TC_CONS_FIX_NEW
  1426.       TC_CONS_FIX_NEW (lie->frag,
  1427.                lie->word_goes_here - lie->frag->fr_literal,
  1428.                2, &exp);
  1429. #else
  1430.       fix_new_exp (lie->frag,
  1431.                lie->word_goes_here - lie->frag->fr_literal,
  1432.                2, &exp, 0, BFD_RELOC_NONE);
  1433. #endif
  1434. #else
  1435. #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
  1436.       fix_new_exp (lie->frag,
  1437.                lie->word_goes_here - lie->frag->fr_literal,
  1438.                2, &exp, 0, NO_RELOC);
  1439. #else
  1440. #ifdef TC_NS32K
  1441.       fix_new_ns32k_exp (lie->frag,
  1442.                  lie->word_goes_here - lie->frag->fr_literal,
  1443.                  2, &exp, 0, 0, 2, 0, 0);
  1444. #else
  1445.       fix_new_exp (lie->frag,
  1446.                lie->word_goes_here - lie->frag->fr_literal,
  1447.                2, &exp, 0, 0);
  1448. #endif /* TC_NS32K */
  1449. #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
  1450. #endif /* BFD_ASSEMBLER */
  1451.       *prevP = lie->next_broken_word;
  1452.     }
  1453.       else
  1454.     prevP = &(lie->next_broken_word);
  1455.  
  1456.     for (lie = broken_words; lie;)
  1457.       {
  1458.     struct broken_word *untruth;
  1459.     char *table_ptr;
  1460.     addressT table_addr;
  1461.     addressT from_addr, to_addr;
  1462.     int n, m;
  1463.  
  1464.     fragP = lie->dispfrag;
  1465.  
  1466.     /* Find out how many broken_words go here.  */
  1467.     n = 0;
  1468.     for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
  1469.       if (untruth->added == 1)
  1470.         n++;
  1471.  
  1472.     table_ptr = lie->dispfrag->fr_opcode;
  1473.     table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
  1474.     /* Create the jump around the long jumps.  This is a short
  1475.        jump from table_ptr+0 to table_ptr+n*long_jump_size.  */
  1476.     from_addr = table_addr;
  1477.     to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
  1478.     md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
  1479.     table_ptr += md_short_jump_size;
  1480.     table_addr += md_short_jump_size;
  1481.  
  1482.     for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
  1483.       {
  1484.         if (lie->added == 2)
  1485.           continue;
  1486.         /* Patch the jump table */
  1487.         /* This is the offset from ??? to table_ptr+0 */
  1488.         to_addr = table_addr - S_GET_VALUE (lie->sub);
  1489. #ifdef BFD_ASSEMBLER
  1490.         to_addr -= lie->sub->sy_frag->fr_address;
  1491. #endif
  1492.         md_number_to_chars (lie->word_goes_here, to_addr, 2);
  1493.         for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
  1494.           {
  1495.         if (untruth->use_jump == lie)
  1496.           md_number_to_chars (untruth->word_goes_here, to_addr, 2);
  1497.           }
  1498.  
  1499.         /* Install the long jump */
  1500.         /* this is a long jump from table_ptr+0 to the final target */
  1501.         from_addr = table_addr;
  1502.         to_addr = S_GET_VALUE (lie->add) + lie->addnum;
  1503. #ifdef BFD_ASSEMBLER
  1504.         to_addr += lie->add->sy_frag->fr_address;
  1505. #endif
  1506.         md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
  1507.         table_ptr += md_long_jump_size;
  1508.         table_addr += md_long_jump_size;
  1509.       }
  1510.       }
  1511.   }
  1512. #endif /* not WORKING_DOT_WORD */
  1513.  
  1514. #ifndef BFD_ASSEMBLER
  1515. #ifndef    OBJ_VMS
  1516.   {                /* not vms */
  1517.     char *the_object_file;
  1518.     long object_file_size;
  1519.     /*
  1520.      * Scan every FixS performing fixups. We had to wait until now to do
  1521.      * this because md_convert_frag() may have made some fixSs.
  1522.      */
  1523.     int trsize, drsize;
  1524.  
  1525.     subseg_change (SEG_TEXT, 0);
  1526.     trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
  1527.     subseg_change (SEG_DATA, 0);
  1528.     drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
  1529.     H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
  1530.  
  1531.     /* FIXME move this stuff into the pre-write-hook */
  1532.     H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
  1533.     H_SET_ENTRY_POINT (&headers, 0);
  1534.  
  1535.     obj_pre_write_hook (&headers);    /* extra coff stuff */
  1536.  
  1537.     object_file_size = H_GET_FILE_SIZE (&headers);
  1538.     next_object_file_charP = the_object_file = xmalloc (object_file_size);
  1539.  
  1540.     output_file_create (out_file_name);
  1541.  
  1542.     obj_header_append (&next_object_file_charP, &headers);
  1543.  
  1544.     know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
  1545.  
  1546.     /*
  1547.      * Emit code.
  1548.      */
  1549.     for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
  1550.       {
  1551.     register long count;
  1552.     register char *fill_literal;
  1553.     register long fill_size;
  1554.  
  1555.     PROGRESS (1);
  1556.     know (fragP->fr_type == rs_fill);
  1557.     append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
  1558.     fill_literal = fragP->fr_literal + fragP->fr_fix;
  1559.     fill_size = fragP->fr_var;
  1560.     know (fragP->fr_offset >= 0);
  1561.  
  1562.     for (count = fragP->fr_offset; count; count--)
  1563.       {
  1564.         append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
  1565.       }            /* for each  */
  1566.  
  1567.       }                /* for each code frag. */
  1568.  
  1569.     know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
  1570.  
  1571.     /*
  1572.      * Emit relocations.
  1573.      */
  1574.     obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
  1575.     know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers) + H_GET_TEXT_RELOCATION_SIZE (&headers)));
  1576. #ifdef TC_I960
  1577.     /* Make addresses in data relocation directives relative to beginning of
  1578.      * first data fragment, not end of last text fragment:  alignment of the
  1579.      * start of the data segment may place a gap between the segments.
  1580.      */
  1581.     obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
  1582. #else /* TC_I960 */
  1583.     obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
  1584. #endif /* TC_I960 */
  1585.  
  1586.     know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers) + H_GET_TEXT_RELOCATION_SIZE (&headers) + H_GET_DATA_RELOCATION_SIZE (&headers)));
  1587.  
  1588.     /*
  1589.      * Emit line number entries.
  1590.      */
  1591.     OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
  1592.     know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers) + H_GET_TEXT_RELOCATION_SIZE (&headers) + H_GET_DATA_RELOCATION_SIZE (&headers) + H_GET_LINENO_SIZE (&headers)));
  1593.  
  1594.     /*
  1595.      * Emit symbols.
  1596.      */
  1597.     obj_emit_symbols (&next_object_file_charP, symbol_rootP);
  1598.     know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers) + H_GET_TEXT_RELOCATION_SIZE (&headers) + H_GET_DATA_RELOCATION_SIZE (&headers) + H_GET_LINENO_SIZE (&headers) + H_GET_SYMBOL_TABLE_SIZE (&headers)));
  1599.  
  1600.     /*
  1601.      * Emit strings.
  1602.      */
  1603.  
  1604.     if (string_byte_count > 0)
  1605.       {
  1606.     obj_emit_strings (&next_object_file_charP);
  1607.       }                /* only if we have a string table */
  1608.  
  1609. #ifdef BFD_HEADERS
  1610.     bfd_seek (stdoutput, 0, 0);
  1611.     bfd_write (the_object_file, 1, object_file_size, stdoutput);
  1612. #else
  1613.  
  1614.     /* Write the data to the file */
  1615.     output_file_append (the_object_file, object_file_size, out_file_name);
  1616.     free (the_object_file);
  1617. #endif
  1618.   }                /* non vms output */
  1619. #else /* OBJ_VMS */
  1620.   /*
  1621.    *    Now do the VMS-dependent part of writing the object file
  1622.    */
  1623.   vms_write_object_file (H_GET_TEXT_SIZE (&headers),
  1624.              H_GET_DATA_SIZE (&headers),
  1625.              H_GET_BSS_SIZE (&headers),
  1626.              text_frag_root, data_frag_root);
  1627. #endif /* OBJ_VMS */
  1628. #else /* BFD_ASSEMBLER */
  1629.  
  1630.   /* Resolve symbol values.  This needs to be done before processing
  1631.      the relocations.  */
  1632.   if (symbol_rootP)
  1633.     {
  1634.       symbolS *symp;
  1635.  
  1636.       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
  1637.     if (!symp->sy_resolved)
  1638.       resolve_symbol_value (symp);
  1639.     }
  1640.  
  1641.   PROGRESS (1);
  1642.  
  1643.   bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
  1644.  
  1645.   /* Set up symbol table, and write it out.  */
  1646.   if (symbol_rootP)
  1647.     {
  1648.       symbolS *symp;
  1649.  
  1650.       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
  1651.     {
  1652.       int punt = 0;
  1653.       const char *name;
  1654.  
  1655.       if (symp->sy_mri_common)
  1656.         {
  1657.           if (S_IS_EXTERNAL (symp))
  1658.         as_bad ("%s: global symbols not supported in common sections",
  1659.             S_GET_NAME (symp));
  1660.           symbol_remove (symp, &symbol_rootP, &symbol_lastP);
  1661.           continue;
  1662.         }
  1663.  
  1664.       name = S_GET_NAME (symp);
  1665.       if (name)
  1666.         {
  1667.           const char *name2 = decode_local_label_name ((char *)S_GET_NAME (symp));
  1668.           /* They only differ if `name' is a fb or dollar local
  1669.          label name.  */
  1670.           if (name2 != name && ! S_IS_DEFINED (symp))
  1671.         as_bad ("local label %s is not defined", name2);
  1672.         }
  1673.  
  1674.       /* Do it again, because adjust_reloc_syms might introduce
  1675.          more symbols.  They'll probably only be section symbols,
  1676.          but they'll still need to have the values computed.  */
  1677.       if (! symp->sy_resolved)
  1678.         {
  1679.           if (symp->sy_value.X_op == O_constant)
  1680.         {
  1681.           /* This is the normal case; skip the call.  */
  1682.           S_SET_VALUE (symp,
  1683.                    (S_GET_VALUE (symp)
  1684.                 + symp->sy_frag->fr_address));
  1685.           symp->sy_resolved = 1;
  1686.         }
  1687.           else
  1688.         resolve_symbol_value (symp);
  1689.         }
  1690.  
  1691.       /* Skip symbols which were equated to undefined or common
  1692.              symbols.  */
  1693.       if (symp->sy_value.X_op == O_symbol
  1694.           && (! S_IS_DEFINED (symp) || S_IS_COMMON (symp)))
  1695.         {
  1696.           symbol_remove (symp, &symbol_rootP, &symbol_lastP);
  1697.           continue;
  1698.         }
  1699.  
  1700.       /* So far, common symbols have been treated like undefined symbols.
  1701.          Put them in the common section now.  */
  1702.       if (S_IS_DEFINED (symp) == 0
  1703.           && S_GET_VALUE (symp) != 0)
  1704.         S_SET_SEGMENT (symp, bfd_com_section_ptr);
  1705. #if 0
  1706.       printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
  1707.           S_GET_NAME (symp), symp,
  1708.           S_GET_VALUE (symp),
  1709.           symp->bsym->flags,
  1710.           segment_name (symp->bsym->section));
  1711. #endif
  1712.  
  1713. #ifdef obj_frob_symbol
  1714.       obj_frob_symbol (symp, punt);
  1715. #endif
  1716. #ifdef tc_frob_symbol
  1717.       if (! punt || symp->sy_used_in_reloc)
  1718.         tc_frob_symbol (symp, punt);
  1719. #endif
  1720.  
  1721.       /* If we don't want to keep this symbol, splice it out of
  1722.          the chain now.  If EMIT_SECTION_SYMBOLS is 0, we never
  1723.          want section symbols.  Otherwise, we skip local symbols
  1724.          and symbols that the frob_symbol macros told us to punt,
  1725.          but we keep such symbols if they are used in relocs.  */
  1726.       if ((! EMIT_SECTION_SYMBOLS
  1727.            && (symp->bsym->flags & BSF_SECTION_SYM) != 0)
  1728.           /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
  1729.          opposites.  Sometimes the former checks flags and the
  1730.          latter examines the name...  */
  1731.           || (!S_IS_EXTERN (symp)
  1732.           && (S_IS_LOCAL (symp) || punt)
  1733.           && ! symp->sy_used_in_reloc))
  1734.         {
  1735.           symbol_remove (symp, &symbol_rootP, &symbol_lastP);
  1736.           /* After symbol_remove, symbol_next(symp) still returns
  1737.          the one that came after it in the chain.  So we don't
  1738.          need to do any extra cleanup work here.  */
  1739.  
  1740.           continue;
  1741.         }
  1742.  
  1743.       /* Make sure we really got a value for the symbol.  */
  1744.       if (! symp->sy_resolved)
  1745.         {
  1746.           as_bad ("can't resolve value for symbol \"%s\"",
  1747.               S_GET_NAME (symp));
  1748.           symp->sy_resolved = 1;
  1749.         }
  1750.  
  1751.       /* Set the value into the BFD symbol.  Up til now the value
  1752.          has only been kept in the gas symbolS struct.  */
  1753.       symp->bsym->value = S_GET_VALUE (symp);
  1754.     }
  1755.     }
  1756.  
  1757.   PROGRESS (1);
  1758.  
  1759.   /* Now do any format-specific adjustments to the symbol table, such
  1760.      as adding file symbols.  */
  1761. #ifdef tc_adjust_symtab
  1762.   tc_adjust_symtab ();
  1763. #endif
  1764. #ifdef obj_adjust_symtab
  1765.   obj_adjust_symtab ();
  1766. #endif
  1767.  
  1768.   /* Now that all the sizes are known, and contents correct, we can
  1769.      start writing to the file.  */
  1770.   set_symtab ();
  1771.  
  1772.   /* If *_frob_file changes the symbol value at this point, it is
  1773.      responsible for moving the changed value into symp->bsym->value
  1774.      as well.  Hopefully all symbol value changing can be done in
  1775.      *_frob_symbol.  */
  1776. #ifdef tc_frob_file
  1777.   tc_frob_file ();
  1778. #endif
  1779. #ifdef obj_frob_file
  1780.   obj_frob_file ();
  1781. #endif
  1782.  
  1783.   bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
  1784.  
  1785.   bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
  1786. #endif /* BFD_ASSEMBLER */
  1787. }
  1788. #endif /* ! BFD */
  1789.  
  1790. /*
  1791.  *            relax_segment()
  1792.  *
  1793.  * Now we have a segment, not a crowd of sub-segments, we can make fr_address
  1794.  * values.
  1795.  *
  1796.  * Relax the frags.
  1797.  *
  1798.  * After this, all frags in this segment have addresses that are correct
  1799.  * within the segment. Since segments live in different file addresses,
  1800.  * these frag addresses may not be the same as final object-file addresses.
  1801.  */
  1802.  
  1803. #ifndef md_relax_frag
  1804. #ifdef TC_GENERIC_RELAX_TABLE
  1805.  
  1806. /* Subroutines of relax_segment.  */
  1807. static int 
  1808. is_dnrange (f1, f2)
  1809.      struct frag *f1;
  1810.      struct frag *f2;
  1811. {
  1812.   for (; f1; f1 = f1->fr_next)
  1813.     if (f1->fr_next == f2)
  1814.       return 1;
  1815.   return 0;
  1816. }
  1817.  
  1818. #endif /* defined (TC_GENERIC_RELAX_TABLE) */
  1819. #endif /* ! defined (md_relax_frag) */
  1820.  
  1821. /* Relax_align. Advance location counter to next address that has 'alignment'
  1822.    lowest order bits all 0s, return size of adjustment made.  */
  1823. static relax_addressT
  1824. relax_align (address, alignment)
  1825.      register relax_addressT address;    /* Address now. */
  1826.      register int alignment;    /* Alignment (binary). */
  1827. {
  1828.   relax_addressT mask;
  1829.   relax_addressT new_address;
  1830.  
  1831.   mask = ~((~0) << alignment);
  1832.   new_address = (address + mask) & (~mask);
  1833. #ifdef LINKER_RELAXING_SHRINKS_ONLY
  1834.   if (linkrelax)
  1835.     /* We must provide lots of padding, so the linker can discard it
  1836.        when needed.  The linker will not add extra space, ever.  */
  1837.     new_address += (1 << alignment);
  1838. #endif
  1839.   return (new_address - address);
  1840. }
  1841.  
  1842. void 
  1843. relax_segment (segment_frag_root, segment)
  1844.      struct frag *segment_frag_root;
  1845.      segT segment;
  1846. {
  1847.   register struct frag *fragP;
  1848.   register relax_addressT address;
  1849. #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
  1850.   know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
  1851. #endif
  1852.   /* In case md_estimate_size_before_relax() wants to make fixSs. */
  1853.   subseg_change (segment, 0);
  1854.  
  1855.   /* For each frag in segment: count and store  (a 1st guess of)
  1856.      fr_address.  */
  1857.   address = 0;
  1858.   for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
  1859.     {
  1860.       fragP->fr_address = address;
  1861.       address += fragP->fr_fix;
  1862.  
  1863.       switch (fragP->fr_type)
  1864.     {
  1865.     case rs_fill:
  1866.       address += fragP->fr_offset * fragP->fr_var;
  1867.       break;
  1868.  
  1869.     case rs_align:
  1870.     case rs_align_code:
  1871.       {
  1872.         int offset = relax_align (address, (int) fragP->fr_offset);
  1873.         if (offset % fragP->fr_var != 0)
  1874.           {
  1875.         as_bad ("alignment padding (%d bytes) not a multiple of %ld",
  1876.             offset, (long) fragP->fr_var);
  1877.         offset -= (offset % fragP->fr_var);
  1878.           }
  1879.         address += offset;
  1880.       }
  1881.       break;
  1882.  
  1883.     case rs_org:
  1884.     case rs_space:
  1885.       /* Assume .org is nugatory. It will grow with 1st relax.  */
  1886.       break;
  1887.  
  1888.     case rs_machine_dependent:
  1889.       address += md_estimate_size_before_relax (fragP, segment);
  1890.       break;
  1891.  
  1892. #ifndef WORKING_DOT_WORD
  1893.       /* Broken words don't concern us yet */
  1894.     case rs_broken_word:
  1895.       break;
  1896. #endif
  1897.  
  1898.     default:
  1899.       BAD_CASE (fragP->fr_type);
  1900.       break;
  1901.     }            /* switch(fr_type) */
  1902.     }                /* for each frag in the segment */
  1903.  
  1904.   /* Do relax().  */
  1905.   {
  1906.     long stretch;    /* May be any size, 0 or negative. */
  1907.     /* Cumulative number of addresses we have */
  1908.     /* relaxed this pass. */
  1909.     /* We may have relaxed more than one address. */
  1910.     long stretched;    /* Have we stretched on this pass? */
  1911.     /* This is 'cuz stretch may be zero, when, in fact some piece of code
  1912.        grew, and another shrank.  If a branch instruction doesn't fit anymore,
  1913.        we could be scrod.  */
  1914.  
  1915.     do
  1916.       {
  1917.     stretch = stretched = 0;
  1918.     for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
  1919.       {
  1920.         long growth = 0;
  1921.         unsigned long was_address;
  1922.         long offset;
  1923.         symbolS *symbolP;
  1924.         long target;
  1925.         long after;
  1926.  
  1927.         was_address = fragP->fr_address;
  1928.         address = fragP->fr_address += stretch;
  1929.         symbolP = fragP->fr_symbol;
  1930.         offset = fragP->fr_offset;
  1931.  
  1932.         switch (fragP->fr_type)
  1933.           {
  1934.           case rs_fill:    /* .fill never relaxes. */
  1935.         growth = 0;
  1936.         break;
  1937.  
  1938. #ifndef WORKING_DOT_WORD
  1939.         /* JF:  This is RMS's idea.  I do *NOT* want to be blamed
  1940.            for it I do not want to write it.  I do not want to have
  1941.            anything to do with it.  This is not the proper way to
  1942.            implement this misfeature.  */
  1943.           case rs_broken_word:
  1944.         {
  1945.           struct broken_word *lie;
  1946.           struct broken_word *untruth;
  1947.  
  1948.           /* Yes this is ugly (storing the broken_word pointer
  1949.              in the symbol slot).  Still, this whole chunk of
  1950.              code is ugly, and I don't feel like doing anything
  1951.              about it.  Think of it as stubbornness in action.  */
  1952.           growth = 0;
  1953.           for (lie = (struct broken_word *) (fragP->fr_symbol);
  1954.                lie && lie->dispfrag == fragP;
  1955.                lie = lie->next_broken_word)
  1956.             {
  1957.  
  1958.               if (lie->added)
  1959.             continue;
  1960.  
  1961.               offset = (lie->add->sy_frag->fr_address
  1962.                 + S_GET_VALUE (lie->add)
  1963.                 + lie->addnum
  1964.                 - (lie->sub->sy_frag->fr_address
  1965.                    + S_GET_VALUE (lie->sub)));
  1966.               if (offset <= -32768 || offset >= 32767)
  1967.             {
  1968.               if (flag_warn_displacement)
  1969.                 {
  1970.                   char buf[50];
  1971.                   sprint_value (buf, (addressT) lie->addnum);
  1972.                   as_warn (".word %s-%s+%s didn't fit",
  1973.                        S_GET_NAME (lie->add),
  1974.                        S_GET_NAME (lie->sub),
  1975.                        buf);
  1976.                 }
  1977.               lie->added = 1;
  1978.               if (fragP->fr_subtype == 0)
  1979.                 {
  1980.                   fragP->fr_subtype++;
  1981.                   growth += md_short_jump_size;
  1982.                 }
  1983.               for (untruth = lie->next_broken_word;
  1984.                    untruth && untruth->dispfrag == lie->dispfrag;
  1985.                    untruth = untruth->next_broken_word)
  1986.                 if ((untruth->add->sy_frag == lie->add->sy_frag)
  1987.                 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
  1988.                   {
  1989.                 untruth->added = 2;
  1990.                 untruth->use_jump = lie;
  1991.                   }
  1992.               growth += md_long_jump_size;
  1993.             }
  1994.             }
  1995.  
  1996.           break;
  1997.         }        /* case rs_broken_word */
  1998. #endif
  1999.           case rs_align:
  2000.           case rs_align_code:
  2001.         growth = (relax_align ((relax_addressT) (address
  2002.                              + fragP->fr_fix),
  2003.                        (int) offset)
  2004.               - relax_align ((relax_addressT) (was_address
  2005.                                + fragP->fr_fix),
  2006.                      (int) offset));
  2007.         break;
  2008.  
  2009.           case rs_org:
  2010.         target = offset;
  2011.  
  2012.         if (symbolP)
  2013.           {
  2014. #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
  2015.             know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
  2016.               || (S_GET_SEGMENT (symbolP) == SEG_DATA)
  2017.               || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
  2018.               || S_GET_SEGMENT (symbolP) == SEG_BSS);
  2019.             know (symbolP->sy_frag);
  2020.             know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
  2021.               || (symbolP->sy_frag == &zero_address_frag));
  2022. #endif
  2023.             target += S_GET_VALUE (symbolP)
  2024.               + symbolP->sy_frag->fr_address;
  2025.           }        /* if we have a symbol */
  2026.  
  2027.         know (fragP->fr_next);
  2028.         after = fragP->fr_next->fr_address;
  2029.         growth = target - after;
  2030.         if (growth < 0)
  2031.           {
  2032.             /* Growth may be negative, but variable part of frag
  2033.                cannot have fewer than 0 chars.  That is, we can't
  2034.                .org backwards. */
  2035.             as_bad ("attempt to .org backwards ignored");
  2036.             growth = 0;
  2037.           }
  2038.  
  2039.         growth -= stretch;    /* This is an absolute growth factor */
  2040.         break;
  2041.  
  2042.           case rs_space:
  2043.         if (symbolP)
  2044.           {
  2045.             growth = S_GET_VALUE (symbolP);
  2046.             if (symbolP->sy_frag != &zero_address_frag)
  2047.               as_bad (".space specifies non-absolute value");
  2048.             fragP->fr_symbol = 0;
  2049.             if (growth < 0)
  2050.               {
  2051.             as_warn (".space or .fill with negative value, ignored");
  2052.             growth = 0;
  2053.               }
  2054.           }
  2055.         else
  2056.           growth = 0;
  2057.         break;
  2058.  
  2059.           case rs_machine_dependent:
  2060. #ifdef md_relax_frag
  2061.         growth = md_relax_frag (fragP, stretch);
  2062. #else
  2063. #ifdef TC_GENERIC_RELAX_TABLE
  2064.         /* The default way to relax a frag is to look through
  2065.            md_relax_table.  */
  2066.         {
  2067.           const relax_typeS *this_type;
  2068.           const relax_typeS *start_type;
  2069.           relax_substateT next_state;
  2070.           relax_substateT this_state;
  2071.           long aim;
  2072.           const relax_typeS *table = TC_GENERIC_RELAX_TABLE;
  2073.  
  2074.           this_state = fragP->fr_subtype;
  2075.           start_type = this_type = table + this_state;
  2076.           target = offset;
  2077.  
  2078.           if (symbolP)
  2079.             {
  2080. #ifndef DIFF_EXPR_OK
  2081. #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
  2082.               know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
  2083.                 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
  2084.                 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
  2085.                 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
  2086. #endif
  2087.               know (symbolP->sy_frag);
  2088. #endif
  2089.               know (!(S_GET_SEGMENT (symbolP) == absolute_section)
  2090.                 || symbolP->sy_frag == &zero_address_frag);
  2091.               target +=
  2092.             S_GET_VALUE (symbolP)
  2093.             + symbolP->sy_frag->fr_address;
  2094.  
  2095.               /* If frag has yet to be reached on this pass,
  2096.              assume it will move by STRETCH just as we did.
  2097.              If this is not so, it will be because some frag
  2098.              between grows, and that will force another pass.
  2099.  
  2100.              Beware zero-length frags.
  2101.  
  2102.              There should be a faster way to do this.  */
  2103.  
  2104.               if (symbolP->sy_frag->fr_address >= was_address
  2105.               && is_dnrange (fragP, symbolP->sy_frag))
  2106.             {
  2107.               target += stretch;
  2108.             }
  2109.             }
  2110.  
  2111.           aim = target - address - fragP->fr_fix;
  2112. #ifdef TC_PCREL_ADJUST
  2113.           /* Currently only the ns32k family needs this */
  2114.           aim += TC_PCREL_ADJUST(fragP);
  2115. #else
  2116.           /* This machine doesn't want to use pcrel_adjust.
  2117.              In that case, pcrel_adjust should be zero.  */
  2118.           assert (fragP->fr_pcrel_adjust == 0);
  2119. #endif
  2120.  
  2121.           if (aim < 0)
  2122.             {
  2123.               /* Look backwards. */
  2124.               for (next_state = this_type->rlx_more; next_state;)
  2125.             if (aim >= this_type->rlx_backward)
  2126.               next_state = 0;
  2127.             else
  2128.               {
  2129.                 /* Grow to next state. */
  2130.                 this_state = next_state;
  2131.                 this_type = table + this_state;
  2132.                 next_state = this_type->rlx_more;
  2133.               }
  2134.             }
  2135.           else
  2136.             {
  2137. #ifdef M68K_AIM_KLUDGE
  2138.               M68K_AIM_KLUDGE (aim, this_state, this_type);
  2139. #endif
  2140.               /* Look forwards. */
  2141.               for (next_state = this_type->rlx_more; next_state;)
  2142.             if (aim <= this_type->rlx_forward)
  2143.               next_state = 0;
  2144.             else
  2145.               {
  2146.                 /* Grow to next state. */
  2147.                 this_state = next_state;
  2148.                 this_type = table + this_state;
  2149.                 next_state = this_type->rlx_more;
  2150.               }
  2151.             }
  2152.  
  2153.           growth = this_type->rlx_length - start_type->rlx_length;
  2154.           if (growth != 0)
  2155.             fragP->fr_subtype = this_state;
  2156.         }
  2157. #endif /* TC_GENERIC_RELAX_TABLE */
  2158. #endif
  2159.         break;
  2160.  
  2161.           default:
  2162.         BAD_CASE (fragP->fr_type);
  2163.         break;
  2164.           }
  2165.         if (growth)
  2166.           {
  2167.         stretch += growth;
  2168.         stretched++;
  2169.           }
  2170.       }            /* For each frag in the segment. */
  2171.       }
  2172.     while (stretched);        /* Until nothing further to relax. */
  2173.   }                /* do_relax */
  2174.  
  2175.   /*
  2176.    * We now have valid fr_address'es for each frag.
  2177.    */
  2178.  
  2179.   /*
  2180.    * All fr_address's are correct, relative to their own segment.
  2181.    * We have made all the fixS we will ever make.
  2182.    */
  2183. }                /* relax_segment() */
  2184.  
  2185. #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
  2186.  
  2187. #ifndef TC_RELOC_RTSYM_LOC_FIXUP
  2188. #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
  2189. #endif
  2190.  
  2191. /* fixup_segment()
  2192.  
  2193.    Go through all the fixS's in a segment and see which ones can be
  2194.    handled now.  (These consist of fixS where we have since discovered
  2195.    the value of a symbol, or the address of the frag involved.)
  2196.    For each one, call md_apply_fix to put the fix into the frag data.
  2197.  
  2198.    Result is a count of how many relocation structs will be needed to
  2199.    handle the remaining fixS's that we couldn't completely handle here.
  2200.    These will be output later by emit_relocations().  */
  2201.  
  2202. static long
  2203. fixup_segment (fixP, this_segment_type)
  2204.      register fixS *fixP;
  2205.      segT this_segment_type;    /* N_TYPE bits for segment. */
  2206. {
  2207.   long seg_reloc_count = 0;
  2208.   symbolS *add_symbolP;
  2209.   symbolS *sub_symbolP;
  2210.   valueT add_number;
  2211.   int size;
  2212.   char *place;
  2213.   long where;
  2214.   int pcrel, plt;
  2215.   fragS *fragP;
  2216.   segT add_symbol_segment = absolute_section;
  2217.   
  2218.   /* If the linker is doing the relaxing, we must not do any fixups.
  2219.  
  2220.      Well, strictly speaking that's not true -- we could do any that are
  2221.      PC-relative and don't cross regions that could change size.  And for the
  2222.      i960 (the only machine for which we've got a relaxing linker right now),
  2223.      we might be able to turn callx/callj into bal anyways in cases where we
  2224.      know the maximum displacement.  */
  2225.   if (linkrelax)
  2226.     {
  2227.       for (; fixP; fixP = fixP->fx_next)
  2228.     seg_reloc_count++;
  2229.       TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
  2230.       return seg_reloc_count;
  2231.     }
  2232.  
  2233.   for (; fixP; fixP = fixP->fx_next)
  2234.     {
  2235. #ifdef DEBUG5
  2236.       fprintf (stderr, "\nprocessing fixup:\n");
  2237.       print_fixup (fixP);
  2238. #endif
  2239.  
  2240.       fragP = fixP->fx_frag;
  2241.       know (fragP);
  2242.       where = fixP->fx_where;
  2243.       place = fragP->fr_literal + where;
  2244.       size = fixP->fx_size;
  2245.       add_symbolP = fixP->fx_addsy;
  2246. #ifdef TC_VALIDATE_FIX
  2247.       TC_VALIDATE_FIX (fixP, this_segment_type, skip);
  2248. #endif
  2249.       sub_symbolP = fixP->fx_subsy;
  2250.       add_number = fixP->fx_offset;
  2251.       pcrel = fixP->fx_pcrel;
  2252.       plt = fixP->fx_plt;
  2253.  
  2254.       if (add_symbolP != NULL
  2255.       && add_symbolP->sy_mri_common)
  2256.     {
  2257.       know (add_symbolP->sy_value.X_op == O_symbol);
  2258.       add_number += S_GET_VALUE (add_symbolP);
  2259.       fixP->fx_offset = add_number;
  2260.       add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
  2261.     }
  2262.  
  2263.       if (add_symbolP)
  2264.     add_symbol_segment = S_GET_SEGMENT (add_symbolP);
  2265.       
  2266.       if (sub_symbolP)
  2267.     {
  2268.       resolve_symbol_value (sub_symbolP);
  2269.       if (add_symbolP == NULL || add_symbol_segment == absolute_section)
  2270.         {
  2271.           if (add_symbolP != NULL)
  2272.         {
  2273.           add_number += S_GET_VALUE (add_symbolP);
  2274.           add_symbolP = NULL;
  2275.           fixP->fx_addsy = NULL;
  2276.         }
  2277.  
  2278.           /* It's just -sym */
  2279.           if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
  2280.         {
  2281.           add_number -= S_GET_VALUE (sub_symbolP);
  2282.           fixP->fx_subsy = NULL;
  2283.         }
  2284.           else if (pcrel
  2285.                && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
  2286.         {
  2287.           /* Should try converting to a constant.  */
  2288.           goto bad_sub_reloc;
  2289.         }
  2290.           else
  2291.           bad_sub_reloc:
  2292.         as_bad_where (fixP->fx_file, fixP->fx_line,
  2293.                   "Negative of non-absolute symbol %s",
  2294.                   S_GET_NAME (sub_symbolP));
  2295.         }
  2296.       else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
  2297.            && SEG_NORMAL (add_symbol_segment))
  2298.         {
  2299.           /* Difference of 2 symbols from same segment.
  2300.          Can't make difference of 2 undefineds: 'value' means
  2301.          something different for N_UNDF. */
  2302. #ifdef TC_I960
  2303.           /* Makes no sense to use the difference of 2 arbitrary symbols
  2304.          as the target of a call instruction.  */
  2305.           if (fixP->fx_tcbit)
  2306.         as_bad_where (fixP->fx_file, fixP->fx_line,
  2307.                   "callj to difference of 2 symbols");
  2308. #endif /* TC_I960 */
  2309.           add_number += S_GET_VALUE (add_symbolP) -
  2310.         S_GET_VALUE (sub_symbolP);
  2311.  
  2312.           add_symbolP = NULL;
  2313.           pcrel = 0;    /* No further pcrel processing. */
  2314.  
  2315.           /* Let the target machine make the final determination
  2316.          as to whether or not a relocation will be needed to
  2317.          handle this fixup.  */
  2318.           if (!TC_FORCE_RELOCATION_SECTION (fixP, this_segment_type))
  2319.         {
  2320.           fixP->fx_pcrel = 0;
  2321.           fixP->fx_addsy = NULL;
  2322.           fixP->fx_subsy = NULL;
  2323.         }
  2324.         }
  2325.       else
  2326.         {
  2327.           /* Different segments in subtraction. */
  2328.           know (!(S_IS_EXTERNAL (sub_symbolP)
  2329.               && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
  2330.  
  2331.           if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
  2332.         add_number -= S_GET_VALUE (sub_symbolP);
  2333.  
  2334. #ifdef DIFF_EXPR_OK
  2335.           else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
  2336. #if 0 /* Do this even if it's already described as pc-relative.  For example,
  2337.      on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
  2338.      pc-relative mode.  */
  2339.                && pcrel
  2340. #endif
  2341.                )
  2342.         {
  2343.           /* Make it pc-relative.  */
  2344.           add_number += (MD_PCREL_FROM_SECTION (fixP, this_segment_type)
  2345.                  - S_GET_VALUE (sub_symbolP));
  2346.           pcrel = 1;
  2347.           fixP->fx_pcrel = 1;
  2348.           sub_symbolP = 0;
  2349.           fixP->fx_subsy = 0;
  2350.         }
  2351. #endif
  2352. #ifdef UNDEFINED_DIFFERENCE_OK
  2353.           /* The PA needs this for PIC code generation.  We basically
  2354.          don't want to do anything if we have the difference of two
  2355.          symbols at this point.  */
  2356.           else if (1)
  2357.         {
  2358.           /* Leave it alone.  */
  2359.         }
  2360. #endif
  2361. #ifdef BFD_ASSEMBLER
  2362.           else if (fixP->fx_r_type == BFD_RELOC_GPREL32
  2363.                || fixP->fx_r_type == BFD_RELOC_GPREL16)
  2364.         {
  2365.           /* Leave it alone.  */
  2366.         }
  2367. #endif
  2368.           else
  2369.         {
  2370.           char buf[50];
  2371.           sprint_value (buf, fragP->fr_address + where);
  2372.           as_bad_where (fixP->fx_file, fixP->fx_line,
  2373.                 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
  2374.                 segment_name (S_GET_SEGMENT (sub_symbolP)),
  2375.                 S_GET_NAME (sub_symbolP), buf);
  2376.         }
  2377.         }
  2378.     }
  2379.  
  2380.       if (add_symbolP)
  2381.     {
  2382.       if (add_symbol_segment == this_segment_type && pcrel && !plt
  2383.           && TC_RELOC_RTSYM_LOC_FIXUP (fixP))
  2384.         {
  2385.           /*
  2386.            * This fixup was made when the symbol's segment was
  2387.            * SEG_UNKNOWN, but it is now in the local segment.
  2388.            * So we know how to do the address without relocation.
  2389.            */
  2390. #ifdef TC_I960
  2391.           /* reloc_callj() may replace a 'call' with a 'calls' or a
  2392.          'bal', in which cases it modifies *fixP as appropriate.
  2393.          In the case of a 'calls', no further work is required,
  2394.          and *fixP has been set up to make the rest of the code
  2395.          below a no-op. */
  2396.           reloc_callj (fixP);
  2397. #endif /* TC_I960 */
  2398.  
  2399.           add_number += S_GET_VALUE (add_symbolP);
  2400.           add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
  2401.           pcrel = 0;    /* Lie. Don't want further pcrel processing. */
  2402.           
  2403.           /* Let the target machine make the final determination
  2404.          as to whether or not a relocation will be needed to
  2405.          handle this fixup.  */
  2406.           if (!TC_FORCE_RELOCATION (fixP))
  2407.         {
  2408.           fixP->fx_pcrel = 0;
  2409.           fixP->fx_addsy = NULL;
  2410.         }
  2411.         }
  2412.       else
  2413.         {
  2414.           if (add_symbol_segment == absolute_section)
  2415.         {
  2416. #ifdef TC_I960
  2417.           /* See comment about reloc_callj() above.  */
  2418.           reloc_callj (fixP);
  2419. #endif /* TC_I960 */
  2420.           add_number += S_GET_VALUE (add_symbolP);
  2421.  
  2422.           /* Let the target machine make the final determination
  2423.              as to whether or not a relocation will be needed to
  2424.              handle this fixup.  */
  2425.           
  2426.           if (!TC_FORCE_RELOCATION (fixP))
  2427.             {
  2428.               fixP->fx_addsy = NULL;
  2429.               add_symbolP = NULL;
  2430.             }
  2431.         }
  2432.           else if (add_symbol_segment == undefined_section
  2433. #ifdef BFD_ASSEMBLER
  2434.                || bfd_is_com_section (add_symbol_segment)
  2435. #endif
  2436.                )
  2437.         {
  2438. #ifdef TC_I960
  2439.           if ((int) fixP->fx_bit_fixP == 13)
  2440.             {
  2441.               /* This is a COBR instruction.  They have only a
  2442.                * 13-bit displacement and are only to be used
  2443.                * for local branches: flag as error, don't generate
  2444.                * relocation.
  2445.                */
  2446.               as_bad_where (fixP->fx_file, fixP->fx_line,
  2447.                     "can't use COBR format with external label");
  2448.               fixP->fx_addsy = NULL;
  2449.               fixP->fx_done = 1;
  2450.               continue;
  2451.             }        /* COBR */
  2452. #endif /* TC_I960 */
  2453.           
  2454. #ifdef OBJ_COFF
  2455. #ifdef TE_I386AIX
  2456.           if (S_IS_COMMON (add_symbolP))
  2457.             add_number += S_GET_VALUE (add_symbolP);
  2458. #endif /* TE_I386AIX */
  2459. #endif /* OBJ_COFF */
  2460.           ++seg_reloc_count;
  2461.         }
  2462.           else
  2463.         {
  2464.           seg_reloc_count++;
  2465. #if !(defined (TC_M68K) && defined (OBJ_ELF))
  2466. #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
  2467.           add_number += S_GET_VALUE (add_symbolP);
  2468. #endif
  2469. #endif
  2470.         }
  2471.         }
  2472.     }
  2473.  
  2474.       if (pcrel)
  2475.     {
  2476.       add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
  2477.       if (add_symbolP == 0)
  2478.         {
  2479. #ifndef BFD_ASSEMBLER
  2480.           fixP->fx_addsy = &abs_symbol;
  2481. #else
  2482.           fixP->fx_addsy = section_symbol (absolute_section);
  2483. #endif
  2484.           fixP->fx_addsy->sy_used_in_reloc = 1;
  2485.           ++seg_reloc_count;
  2486.         }
  2487.     }
  2488.  
  2489.       if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && size > 0)
  2490.     {
  2491.       valueT mask = 0;
  2492.       if (size < sizeof (mask))
  2493.         {
  2494.           /* set all bits to one */
  2495.           mask--;
  2496.           /* Technically, combining these produces an undefined result
  2497.          if size is sizeof (valueT), though I think these two
  2498.          half-way operations should both be defined.  And the
  2499.          compiler should be able to combine them if it's valid on
  2500.          the host architecture.  */
  2501.           mask <<= size * 4;
  2502.           mask <<= size * 4;
  2503.           if ((add_number & mask) != 0
  2504.           && (add_number & mask) != mask)
  2505.         {
  2506.           char buf[50], buf2[50];
  2507.           sprint_value (buf, fragP->fr_address + where);
  2508.           if (add_number > 1000)
  2509.             sprint_value (buf2, add_number);
  2510.           else
  2511.             sprintf (buf2, "%ld", (long) add_number);
  2512.           as_bad_where (fixP->fx_file, fixP->fx_line,
  2513.                 "Value of %s too large for field of %d bytes at %s",
  2514.                 buf2, size, buf);
  2515.         } /* generic error checking */
  2516.         }
  2517. #ifdef WARN_SIGNED_OVERFLOW_WORD
  2518.       /* Warn if a .word value is too large when treated as a signed
  2519.          number.  We already know it is not too negative.  This is to
  2520.          catch over-large switches generated by gcc on the 68k.  */
  2521.       if (!flag_signed_overflow_ok
  2522.           && size == 2
  2523.           && add_number > 0x7fff)
  2524.         as_bad_where (fixP->fx_file, fixP->fx_line,
  2525.               "Signed .word overflow; switch may be too large; %ld at 0x%lx",
  2526.               (long) add_number,
  2527.               (unsigned long) (fragP->fr_address + where));
  2528. #endif
  2529.     }            /* not a bit fix */
  2530.  
  2531.       if (!fixP->fx_done)
  2532.     {
  2533. #ifdef MD_APPLY_FIX3
  2534.       md_apply_fix3 (fixP, &add_number, this_segment_type);
  2535. #else
  2536. #ifdef BFD_ASSEMBLER
  2537.       md_apply_fix (fixP, &add_number);
  2538. #else
  2539.       md_apply_fix (fixP, add_number);
  2540. #endif
  2541. #endif
  2542.  
  2543. #ifndef TC_HANDLES_FX_DONE
  2544.       /* If the tc-* files haven't been converted, assume it's handling
  2545.          it the old way, where a null fx_addsy means that the fix has
  2546.          been applied completely, and no further work is needed.  */
  2547.       if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
  2548.         fixP->fx_done = 1;
  2549. #endif
  2550.     }
  2551. #ifdef TC_VALIDATE_FIX
  2552.     skip: ;
  2553. #endif
  2554. #ifdef DEBUG5
  2555.       fprintf (stderr, "result:\n");
  2556.       print_fixup (fixP);
  2557. #endif
  2558.     }                /* For each fixS in this segment. */
  2559.  
  2560.   TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
  2561.   return seg_reloc_count;
  2562. }
  2563.  
  2564. #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
  2565.  
  2566. void
  2567. number_to_chars_bigendian (buf, val, n)
  2568.      char *buf;
  2569.      valueT val;
  2570.      int n;
  2571. {
  2572.   if (n > sizeof (val)|| n <= 0)
  2573.     abort ();
  2574.   while (n--)
  2575.     {
  2576.       buf[n] = val & 0xff;
  2577.       val >>= 8;
  2578.     }
  2579. }
  2580.  
  2581. void
  2582. number_to_chars_littleendian (buf, val, n)
  2583.      char *buf;
  2584.      valueT val;
  2585.      int n;
  2586. {
  2587.   if (n > sizeof (val) || n <= 0)
  2588.     abort ();
  2589.   while (n--)
  2590.     {
  2591.       *buf++ = val & 0xff;
  2592.       val >>= 8;
  2593.     }
  2594. }
  2595.  
  2596. void
  2597. write_print_statistics (file)
  2598.      FILE *file;
  2599. {
  2600.   fprintf (stderr, "fixups: %d\n", n_fixups);
  2601. }
  2602.  
  2603. /* for debugging */
  2604. extern int indent_level;
  2605. extern void print_symbol_value_1 ();
  2606.  
  2607. void
  2608. print_fixup (fixp)
  2609.      fixS *fixp;
  2610. {
  2611.   indent_level = 1;
  2612.   fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
  2613.   if (fixp->fx_pcrel)
  2614.     fprintf (stderr, " pcrel");
  2615.   if (fixp->fx_pcrel_adjust)
  2616.     fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
  2617.   if (fixp->fx_im_disp)
  2618.     {
  2619. #ifdef TC_NS32K
  2620.       fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
  2621. #else
  2622.       fprintf (stderr, " im_disp");
  2623. #endif
  2624.     }
  2625.   if (fixp->fx_tcbit)
  2626.     fprintf (stderr, " tcbit");
  2627.   if (fixp->fx_done)
  2628.     fprintf (stderr, " done");
  2629.   fprintf (stderr, "\n    size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
  2630.        fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
  2631.        (long) fixp->fx_offset, (long) fixp->fx_addnumber);
  2632. #ifdef BFD_ASSEMBLER
  2633.   fprintf (stderr, "\n    %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
  2634.        fixp->fx_r_type);
  2635. #else
  2636. #ifdef NEED_FX_R_TYPE
  2637.   fprintf (stderr, " r_type=%d", fixp->fx_r_type);
  2638. #endif
  2639. #endif
  2640.   if (fixp->fx_addsy)
  2641.     {
  2642.       fprintf (stderr, "\n   +<");
  2643.       print_symbol_value_1 (stderr, fixp->fx_addsy);
  2644.       fprintf (stderr, ">");
  2645.     }
  2646.   if (fixp->fx_subsy)
  2647.     {
  2648.       fprintf (stderr, "\n   -<");
  2649.       print_symbol_value_1 (stderr, fixp->fx_subsy);
  2650.       fprintf (stderr, ">");
  2651.     }
  2652.   fprintf (stderr, "\n");
  2653. }
  2654.  
  2655. /* end of write.c */
  2656.